.TH std::flat_map::operator= 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::flat_map::operator= \- std::flat_map::operator=

.SH Synopsis
   flat_map& operator=( const flat_map& other );              \fB(1)\fP (since C++23)
                                                                  (implicitly declared)
   flat_map& operator=( flat_map&& other );                   \fB(2)\fP (since C++23)
                                                                  (implicitly declared)
   flat_map& operator=( std::initializer_list<value_type>     \fB(3)\fP (since C++23)
   ilist );

   Replaces the contents of the container adaptor with the contents of given argument.

   1) Copy assignment operator. Replaces the contents with a copy of the contents of
   other. Effectively calls c = other.c; comp = other.comp;.
   2) Move assignment operator. Replaces the contents with those of other using move
   semantics. Effectively calls c = std::move(other.c); comp = std::move(other.comp);.
   3) Replaces the contents with those identified by initializer list ilist.

.SH Parameters

   other - another container adaptor to be used as source
   ilist - initializer list to be used as source

.SH Return value

   *this

.SH Complexity

   1,2) Equivalent to that of operator= of the underlying container.
   3) Linear in the size of *this and ilist.

.SH Example


// Run this code

 #include <flat_map>
 #include <initializer_list>
 #include <print>
 #include <utility>

 int main()
 {
     std::flat_map<int, int> x{{1, 1}, {2, 2}, {3, 3}}, y, z;
     const auto w = {std::pair<const int, int>{4, 4}, {5, 5}, {6, 6}, {7, 7}};

     std::println("Initially:");
     std::println("x = {}", x);
     std::println("y = {}", y);
     std::println("z = {}", z);

     y = x; // overload (1)
     std::println("Copy assignment copies data from x to y:");
     std::println("x = {}", x);
     std::println("y = {}", y);

     z = std::move(x); // overload (2)
     std::println("Move assignment moves data from x to z, modifying both x and z:");
     std::println("x = {}", x);
     std::println("z = {}", z);

     z = w; // overload (3)
     std::println("Assignment of initializer_list w to z:");
     std::println("w = {}", w);
     std::println("z = {}", z);
 }

.SH Output:

 Initially:
 x = {1: 1, 2: 2, 3: 3}
 y = {}
 z = {}
 Copy assignment copies data from x to y:
 x = {1: 1, 2: 2, 3: 3}
 y = {1: 1, 2: 2, 3: 3}
 Move assignment moves data from x to z, modifying both x and z:
 x = {}
 z = {1: 1, 2: 2, 3: 3}
 Assignment of initializer_list w to z:
 w = {4: 4, 5: 5, 6: 6, 7: 7}
 z = {4: 4, 5: 5, 6: 6, 7: 7}

.SH See also

   constructor   constructs the flat_map
                 \fI(public member function)\fP
   replace       replaces the underlying containers
                 \fI(public member function)\fP
